eth/rpc/rpcapi/api_debug.go (1)

88-90: Preserve error cause and keep height as a structured log field.

Use %w and log height separately to maintain traceability and machine-parsable context.

-    err = fmt.Errorf("%s { blockHeight: %d }", err, height)
-    a.logger.Debug("get block failed", "error", err.Error())
+    err = fmt.Errorf("get block at height %d: %w", height, err)
+    a.logger.Debug("get block failed", "height", height, "error", err.Error())

CHANGELOG.md (1)

58-59: Tiny grammar nit for clarity.
“handle native tracer errors JSON-RPC errors” → “handle native tracer errors as JSON-RPC errors”.

eth/rpc/rpcapi/tracing.go (1)

145-147: Good: empty slice on zero txs; minor log fix.

• Returning [] when txs=0 aligns with common RPC behavior. LGTM.
• Prefer using the loop variable for hash to avoid relying on index.

-    for i, blockTx := range blockTxs {
+    for _, blockTx := range blockTxs {
-        decodedTx, err := txDecoder(blockTx)
+        decodedTx, err := txDecoder(blockTx)
         if err != nil {
-            b.logger.Error("failed to decode transaction", "hash", blockTxs[i].Hash(), "error", err.Error())
+            b.logger.Error("failed to decode transaction", "hash", blockTx.Hash(), "error", err.Error())
             continue
         }

Note: Consider unmarshalling into a nil slice (var decodedResults []*evm.TxTraceResult) rather than a pre-sized slice to avoid confusion about lengths.

Also applies to: 156-171

x/sudo/keeper/querier.go (1)

26-28: Accessor looks good; add brief docstring for public method.
Helps discoverability in IDEs.

+// GetZeroGasActors returns the configured zero-gas actors or the default value if unset.
 func (k Keeper) GetZeroGasActors(ctx sdk.Context) sudo.ZeroGasActors {
     return k.ZeroGasActors.GetOr(ctx, sudo.DefaultZeroGasActors())
 }

eth/rpc/rpcapi/tracing_test.go (1)

98-99: Great coverage; also assert JSON-RPC error details.

When wantErr=true, assert the client returns a JSON-RPC error (code/message), not just any error.

@@
 import (
+    "errors"
@@
-    "github.com/NibiruChain/nibiru/v2/eth/rpc"
+    "github.com/NibiruChain/nibiru/v2/eth/rpc"
+    gethrpc "github.com/ethereum/go-ethereum/rpc"
 )
@@
-                if tc.wantErr {
-                    s.Require().Error(err, tc.wantErr)
-                    return
-                }
+                if tc.wantErr {
+                    s.Require().Error(err)
+                    var rpcErr *gethrpc.Error
+                    if errors.As(err, &rpcErr) {
+                        s.NotZero(rpcErr.ErrorCode())
+                        s.Contains(rpcErr.Error(), "timeout")
+                    }
+                    return
+                }
@@
-                if tc.wantErr {
-                    s.Require().Error(err)
-                    return
-                }
+                if tc.wantErr {
+                    s.Require().Error(err)
+                    var rpcErr *gethrpc.Error
+                    if errors.As(err, &rpcErr) {
+                        s.NotZero(rpcErr.ErrorCode())
+                        s.Contains(rpcErr.Error(), "timeout")
+                    }
+                    return
+                }

Optional: add an HTTP-level assertion that "result" is null when error, if your test harness exposes raw JSON.

Also applies to: 128-139, 151-155, 166-171

x/evm/evmstate/grpc_query.go (1)

706-709: Comment typo.

-    // parallel process that generates statesin one thread and traces txs in
+    // parallel process that generates states in one thread and traces txs in

x/evm/evmstate/grpc_query_test.go (1)

855-888: Robust field-by-field comparison with address normalization.

The new comparison logic is significantly more resilient:

• Unmarshals response into structured map
• Normalizes addresses to handle EIP-55 mixed-case vs lowercase
• Handles hex values with case-insensitive comparison

This aligns with the PR objective to make test comparisons less brittle.

Consider adding validation that no unexpected fields are present:

 			}
+			// Optional: Verify no unexpected fields
+			for k := range gotTraceRes {
+				if _, expected := wantResp[k]; !expected {
+					s.T().Logf("Unexpected field in trace result: %s = %v", k, gotTraceRes[k])
+				}
+			}
 		})

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

x/evm/evmstate/grpc_query_test.go (1)

1014-1027: Address comparison differs from TraceTx.

The address field comparison here uses only lowercase normalization (lines 1020-1024), while TraceTx uses gethcommon.HexToAddress for proper address comparison (TraceTx lines 902-909). For consistency and correctness, consider adopting the TraceTx approach.

Apply this pattern from TraceTx:

 			for k, v := range wantResp {
 				gotV, ok := gotTraceRes[k]
 				s.Require().Truef(ok,
 					"expect result.%s field to be present: { got: %s, want: %s }",
 					k, gotTraceRes, wantResp,
 				)
-				if strings.HasPrefix(gotV, "0x") {
-					// Hex addresses aren't case sensitive. Normalize to lower
-					// case for
-					v = strings.ToLower(v)
-					gotV = strings.ToLower(gotV)
+				switch k {
+				case "from", "to":
+					// Compare as addresses (case-insensitive, byte-equal)
+					s.Equalf(
+						gethcommon.HexToAddress(v),
+						gethcommon.HexToAddress(gotV),
+						`mismatch in trace result { key: %s, testCase: "%s" }`, k, tc.name,
+					)
+				default:
+					// If it's hex, ignore case; else exact
+					if strings.HasPrefix(gotV, "0x") {
+						v = strings.ToLower(v)
+						gotV = strings.ToLower(gotV)
+					}
+					s.Equalf(v, gotV, `mismatch in trace result { key: %s, testCase: "%s" }`, k, tc.name)
 				}
-				s.Equalf(v, gotV, `mismatch in trace result { key: %s, testCase: "%s" }`, k, tc.name)
 			}

x/evm/evmstate/grpc_query.go (1)

711-729: Consider populating TxHash field in TxTraceResult.

The changes correctly implement the native tracer behavior by failing the entire block trace on any transaction error. However, based on the TxTraceResult struct definition (which includes a TxHash field), consider setting it for richer trace data:

 	for i, tx := range req.Txs {
 		result := evm.TxTraceResult{}
 		ethTx := tx.AsTransaction()
+		result.TxHash = ethTx.Hash()
 		txConfig.TxHash = ethTx.Hash()
 		txConfig.TxIndex = uint(i)

This would align with the test expectations and provide more complete trace information to clients.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: Unique-Divine
PR: NibiruChain/nibiru#2119
File: x/evm/keeper/bank_extension_test.go:67-71
Timestamp: 2024-12-06T11:54:38.275Z
Learning: When writing tests in `x/evm/keeper/bank_extension_test.go`, prefer comparing gas consumption values as formatted strings using `fmt.Sprintf("%d", value)` instead of numeric values directly in `s.Equalf`. This avoids hexadecimal representations that are hard to read in shell outputs.

Learnt from: Unique-Divine
PR: NibiruChain/nibiru#2385
File: x/evm/keeper/msg_server.go:92-97
Timestamp: 2025-09-16T00:14:44.279Z
Learning: In the EthereumTx function in x/evm/keeper/msg_server.go, the existing pattern of checking `if evmResp != nil` before calling SafeConsumeGas is correct because the control flow already handles the nil case through an early return when there's a consensus error (applyErr != nil && evmResp == nil).

Learnt from: Unique-Divine
PR: NibiruChain/nibiru#2076
File: x/evm/keeper/msg_server.go:115-116
Timestamp: 2024-10-13T05:48:51.771Z
Learning: In the `ApplyEvmTx` function within `x/evm/keeper/msg_server.go`, a zero value for `weiPerGas` is acceptable as it signifies that gas is free. There is no need to check for zero before performing the gas refund in this context.

x/evm/vmtracer.go (1)

70-77: Adding TxHash to TxTraceResult — good for per-tx identification.

JSON tags look right; TxHash non-omitempty ensures presence. Optional: tighten Result to *json.RawMessage to avoid accidental non-JSONable assignments.

+import "encoding/json"
 
 type TxTraceResult struct {
 	TxHash gethcommon.Hash `json:"txHash"`           // transaction hash
-	Result any             `json:"result,omitempty"` // Trace results produced by the tracer
+	Result *json.RawMessage `json:"result,omitempty"` // Trace results produced by the tracer
 	Error  string          `json:"error,omitempty"`  // Trace failure produced by the tracer
 }

x/evm/evmstate/grpc_query.go (2)

694-705: Minor comment fixes for clarity.

Typo and phrasing; suggest tightening.

-// JS tracers (geth only) have high overhead. Tracing for them runs a
-// parallel process that generates statesin one thread and traces txs in
-// separate worker threads. JS tracers store tracing errors for each tx as
-// fields of the returned trace result instead of failing the query.
+// JS tracers (geth only) have high overhead. Tracing runs a parallel process
+// that generates states in one thread and traces txs in worker threads.
+// JS tracers record per‑tx errors in the result instead of failing the query.

---

714-729: TxHash population resolved; preserve gRPC status codes on trace failure.

Setting result.TxHash and txConfig.TxHash looks good and addresses prior gap. However, wrapping a gRPC status error with fmt.Errorf drops the original status code. Either return the original err or re-wrap preserving its code.

Option A (simplest):

-        return nil, fmt.Errorf("trace tx error { txhash: %s, blockHeight: %d }: %w", ethTx.Hash().Hex(), ctx.BlockHeight(), err)
+        return nil, err

Option B (preserve code, keep context):

+        st, ok := grpcstatus.FromError(err)
+        if ok {
+            return nil, grpcstatus.Errorf(st.Code(),
+                "trace tx error { txhash: %s, blockHeight: %d }: %s",
+                ethTx.Hash().Hex(), ctx.BlockHeight(), st.Message())
+        }
-        return nil, fmt.Errorf("trace tx error { txhash: %s, blockHeight: %d }: %w", ethTx.Hash().Hex(), ctx.BlockHeight(), err)
+        return nil, grpcstatus.Errorf(grpccodes.Internal,
+            "trace tx error { txhash: %s, blockHeight: %d }: %s",
+            ethTx.Hash().Hex(), ctx.BlockHeight(), err.Error())

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: Unique-Divine
PR: NibiruChain/nibiru#2385
File: x/evm/keeper/msg_server.go:92-97
Timestamp: 2025-09-16T00:14:44.279Z
Learning: In the EthereumTx function in x/evm/keeper/msg_server.go, the existing pattern of checking `if evmResp != nil` before calling SafeConsumeGas is correct because the control flow already handles the nil case through an early return when there's a consensus error (applyErr != nil && evmResp == nil).

Learnt from: Unique-Divine
PR: NibiruChain/nibiru#2076
File: x/evm/keeper/msg_server.go:115-116
Timestamp: 2024-10-13T05:48:51.771Z
Learning: In the `ApplyEvmTx` function within `x/evm/keeper/msg_server.go`, a zero value for `weiPerGas` is acceptable as it signifies that gas is free. There is no need to check for zero before performing the gas refund in this context.